#include "order_process_manager.h"

Order_Process_Manager *Order_Process_Manager::m_Instance = nullptr;
QMutex Order_Process_Manager::m_mutex;

Order_Process_Manager *Order_Process_Manager::getInstance(QObject *parent)
{
    // 双重检查锁定，保证线程安全且高效
    if (!m_Instance) {
        QMutexLocker locker(&m_mutex); // 自动加锁/解锁，避免死锁
        if (!m_Instance) {
            m_Instance = new Order_Process_Manager(parent);
        }
    }
    return m_Instance;
}

bool Order_Process_Manager::isExistTable()
{
    QString sql = "SELECT ID, LeftAngle,RightAngle,MaterialHeight,MaterialLength,CutCount FROM Order_Process;";

    bool ok = Db->execSql(sql);
    if(!ok)
    {
        qDebug()<<"Cpp:不存在数据库表 Order_Process";

        sql = "CREATE TABLE Order_Process (ID INTEGER PRIMARY KEY ,LeftAngle TEXT,RightAngle TEXT,MaterialHeight TEXT,MaterialLength TEXT,CutCount TEXT);";
        // qDebug()<<"Cpp:创建数据表 Order_Process sql:"<<sql;
        bool ok = Db->execSql(sql);
        if(ok)
        {
            qDebug()<<"Cpp:创建数据表 Order_Process 成功";

            for(int i = 0 ; i < 20* 20; i++)
            {
                addData();
            }

            for(int i =0 ;i < 20*20; i++)
            {
                saveData((i+1),"LeftAngle","45");
                saveData((i+1),"RightAngle","45");
                saveData((i+1),"MaterialHeight","0");
                saveData((i+1),"MaterialLength","0");
                saveData((i+1),"CutCount","0");
            }
        }
        else
        {
            qDebug()<<"Cpp:创建数据表 Order_Process 失败";
            return false;
        }
    }
    else
    {
        getDataByPacket(0);
    }

    return true;
}

void Order_Process_Manager::getAllDataFromSQL()
{
    QSharedPointer<QSqlQuery> result;

    QString sql = "SELECT ID, LeftAngle,RightAngle,MaterialHeight,MaterialLength,CutCount FROM Order_Process ;";

    result.reset(Db->execSql_Result(sql));
    if(!result.isNull())
    {
        while(result->next())
        {

            int id = result->value(0).toInt();

            switch(id)
            {
            case 1:
                setLeftAngle_1(result->value(1).toString());
                setRightAngle_1(result->value(2).toString());
                setMaterialHeight_1(result->value(3).toString());
                setMaterialLength_1(result->value(4).toString());
                setCutCount_1(result->value(5).toString());
                break;
            case 2 :
                setLeftAngle_2(result->value(1).toString());
                setRightAngle_2(result->value(2).toString());
                setMaterialHeight_2(result->value(3).toString());
                setMaterialLength_2(result->value(4).toString());
                setCutCount_2(result->value(5).toString());
                break;
            case 3:
                setLeftAngle_3(result->value(1).toString());
                setRightAngle_3(result->value(2).toString());
                setMaterialHeight_3(result->value(3).toString());
                setMaterialLength_3(result->value(4).toString());
                setCutCount_3(result->value(5).toString());
                break;
            case 4:
                setLeftAngle_4(result->value(1).toString());
                setRightAngle_4(result->value(2).toString());
                setMaterialHeight_4(result->value(3).toString());
                setMaterialLength_4(result->value(4).toString());
                setCutCount_4(result->value(5).toString());
                break;
            case 5:
                setLeftAngle_5(result->value(1).toString());
                setRightAngle_5(result->value(2).toString());
                setMaterialHeight_5(result->value(3).toString());
                setMaterialLength_5(result->value(4).toString());
                setCutCount_5(result->value(5).toString());
                break;
            case 6:
                setLeftAngle_6(result->value(1).toString());
                setRightAngle_6(result->value(2).toString());
                setMaterialHeight_6(result->value(3).toString());
                setMaterialLength_6(result->value(4).toString());
                setCutCount_6(result->value(5).toString());
                break;
            case 7:
                setLeftAngle_7(result->value(1).toString());
                setRightAngle_7(result->value(2).toString());
                setMaterialHeight_7(result->value(3).toString());
                setMaterialLength_7(result->value(4).toString());
                setCutCount_7(result->value(5).toString());
                break;
            case 8:
                setLeftAngle_8(result->value(1).toString());
                setRightAngle_8(result->value(2).toString());
                setMaterialHeight_8(result->value(3).toString());
                setMaterialLength_8(result->value(4).toString());
                setCutCount_8(result->value(5).toString());
                break;
            case 9:
                setLeftAngle_9(result->value(1).toString());
                setRightAngle_9(result->value(2).toString());
                setMaterialHeight_9(result->value(3).toString());
                setMaterialLength_9(result->value(4).toString());
                setCutCount_9(result->value(5).toString());
                break;
            case 10:
                setLeftAngle_10(result->value(1).toString());
                setRightAngle_10(result->value(2).toString());
                setMaterialHeight_10(result->value(3).toString());
                setMaterialLength_10(result->value(4).toString());
                setCutCount_10(result->value(5).toString());
                break;
            case 11:
                setLeftAngle_11(result->value(1).toString());
                setRightAngle_11(result->value(2).toString());
                setMaterialHeight_11(result->value(3).toString());
                setMaterialLength_11(result->value(4).toString());
                setCutCount_11(result->value(5).toString());
                break;
            case 12:
                setLeftAngle_12(result->value(1).toString());
                setRightAngle_12(result->value(2).toString());
                setMaterialHeight_12(result->value(3).toString());
                setMaterialLength_12(result->value(4).toString());
                setCutCount_12(result->value(5).toString());
                break;
            case 13:
                setLeftAngle_13(result->value(1).toString());
                setRightAngle_13(result->value(2).toString());
                setMaterialHeight_13(result->value(3).toString());
                setMaterialLength_13(result->value(4).toString());
                setCutCount_13(result->value(5).toString());
                break;
            case 14:
                setLeftAngle_14(result->value(1).toString());
                setRightAngle_14(result->value(2).toString());
                setMaterialHeight_14(result->value(3).toString());
                setMaterialLength_14(result->value(4).toString());
                setCutCount_14(result->value(5).toString());
                break;
            case 15:
                setLeftAngle_15(result->value(1).toString());
                setRightAngle_15(result->value(2).toString());
                setMaterialHeight_15(result->value(3).toString());
                setMaterialLength_15(result->value(4).toString());
                setCutCount_15(result->value(5).toString());
                break;
            case 16:
                setLeftAngle_16(result->value(1).toString());
                setRightAngle_16(result->value(2).toString());
                setMaterialHeight_16(result->value(3).toString());
                setMaterialLength_16(result->value(4).toString());
                setCutCount_16(result->value(5).toString());
                break;
            case 17:
                setLeftAngle_17(result->value(1).toString());
                setRightAngle_17(result->value(2).toString());
                setMaterialHeight_17(result->value(3).toString());
                setMaterialLength_17(result->value(4).toString());
                setCutCount_17(result->value(5).toString());
                break;
            case 18:
                setLeftAngle_18(result->value(1).toString());
                setRightAngle_18(result->value(2).toString());
                setMaterialHeight_18(result->value(3).toString());
                setMaterialLength_18(result->value(4).toString());
                setCutCount_18(result->value(5).toString());
                break;
            case 19:
                setLeftAngle_19(result->value(1).toString());
                setRightAngle_19(result->value(2).toString());
                setMaterialHeight_19(result->value(3).toString());
                setMaterialLength_19(result->value(4).toString());
                setCutCount_19(result->value(5).toString());
                break;
            case 20:
                setLeftAngle_20(result->value(1).toString());
                setRightAngle_20(result->value(2).toString());
                setMaterialHeight_20(result->value(3).toString());
                setMaterialLength_20(result->value(4).toString());
                setCutCount_20(result->value(5).toString());
                break;
            default:
                break;
            }

        }


        result.clear();
    }
}

void Order_Process_Manager::getDataByPacket(int packetNumber)
{

    QSharedPointer<QSqlQuery> result;


    int downlimit = (packetNumber * 20 + 1);

    int uplimit = (packetNumber * 20 + 20);

    QString sql = QString("SELECT ID, LeftAngle,RightAngle,MaterialHeight,MaterialLength,CutCount FROM Order_Process WHERE ID BETWEEN %1 AND %2 ;").arg(downlimit).arg(uplimit);


    result.reset(Db->execSql_Result(sql));

    if(!result.isNull())
    {
        while(result->next())
        {
            int id = result->value(0).toInt();

            if(id == downlimit )
            {
                setLeftAngle_1(result->value(1).toString());
                setRightAngle_1(result->value(2).toString());
                setMaterialHeight_1(result->value(3).toString());
                setMaterialLength_1(result->value(4).toString());
                setCutCount_1(result->value(5).toString());
            }
            else if(id == (downlimit + 1) )
            {
                setLeftAngle_2(result->value(1).toString());
                setRightAngle_2(result->value(2).toString());
                setMaterialHeight_2(result->value(3).toString());
                setMaterialLength_2(result->value(4).toString());
                setCutCount_2(result->value(5).toString());
            }
            else if(id == (downlimit + 2) )
            {
                setLeftAngle_3(result->value(1).toString());
                setRightAngle_3(result->value(2).toString());
                setMaterialHeight_3(result->value(3).toString());
                setMaterialLength_3(result->value(4).toString());
                setCutCount_3(result->value(5).toString());
            }
            else if(id == (downlimit + 3) )
            {
                setLeftAngle_4(result->value(1).toString());
                setRightAngle_4(result->value(2).toString());
                setMaterialHeight_4(result->value(3).toString());
                setMaterialLength_4(result->value(4).toString());
                setCutCount_4(result->value(5).toString());
            }
            else if(id == (downlimit + 4) )
            {
                setLeftAngle_5(result->value(1).toString());
                setRightAngle_5(result->value(2).toString());
                setMaterialHeight_5(result->value(3).toString());
                setMaterialLength_5(result->value(4).toString());
                setCutCount_5(result->value(5).toString());
            }
            else if(id == (downlimit + 5))
            {
                setLeftAngle_6(result->value(1).toString());
                setRightAngle_6(result->value(2).toString());
                setMaterialHeight_6(result->value(3).toString());
                setMaterialLength_6(result->value(4).toString());
                setCutCount_6(result->value(5).toString());
            }
            else if(id == (downlimit + 6) )
            {
                setLeftAngle_7(result->value(1).toString());
                setRightAngle_7(result->value(2).toString());
                setMaterialHeight_7(result->value(3).toString());
                setMaterialLength_7(result->value(4).toString());
                setCutCount_7(result->value(5).toString());
            }
            else if(id == (downlimit + 7) )
            {
                setLeftAngle_8(result->value(1).toString());
                setRightAngle_8(result->value(2).toString());
                setMaterialHeight_8(result->value(3).toString());
                setMaterialLength_8(result->value(4).toString());
                setCutCount_8(result->value(5).toString());
            }
            else if(id == (downlimit + 8) )
            {
                setLeftAngle_9(result->value(1).toString());
                setRightAngle_9(result->value(2).toString());
                setMaterialHeight_9(result->value(3).toString());
                setMaterialLength_9(result->value(4).toString());
                setCutCount_9(result->value(5).toString());
            }
            else if(id == (downlimit + 9))
            {
                setLeftAngle_10(result->value(1).toString());
                setRightAngle_10(result->value(2).toString());
                setMaterialHeight_10(result->value(3).toString());
                setMaterialLength_10(result->value(4).toString());
                setCutCount_10(result->value(5).toString());
            }
            else if(id == (downlimit + 10) )
            {
                setLeftAngle_11(result->value(1).toString());
                setRightAngle_11(result->value(2).toString());
                setMaterialHeight_11(result->value(3).toString());
                setMaterialLength_11(result->value(4).toString());
                setCutCount_11(result->value(5).toString());
            }
            else if(id == (downlimit + 11))
            {
                setLeftAngle_12(result->value(1).toString());
                setRightAngle_12(result->value(2).toString());
                setMaterialHeight_12(result->value(3).toString());
                setMaterialLength_12(result->value(4).toString());
                setCutCount_12(result->value(5).toString());
            }
            else if(id == (downlimit + 12) )
            {
                setLeftAngle_13(result->value(1).toString());
                setRightAngle_13(result->value(2).toString());
                setMaterialHeight_13(result->value(3).toString());
                setMaterialLength_13(result->value(4).toString());
                setCutCount_13(result->value(5).toString());
            }
            else if(id == (downlimit + 13) )
            {
                setLeftAngle_14(result->value(1).toString());
                setRightAngle_14(result->value(2).toString());
                setMaterialHeight_14(result->value(3).toString());
                setMaterialLength_14(result->value(4).toString());
                setCutCount_14(result->value(5).toString());
            }
            else if(id == (downlimit + 14) )
            {
                setLeftAngle_15(result->value(1).toString());
                setRightAngle_15(result->value(2).toString());
                setMaterialHeight_15(result->value(3).toString());
                setMaterialLength_15(result->value(4).toString());
                setCutCount_15(result->value(5).toString());
            }
            else if(id == (downlimit + 15) )
            {
                setLeftAngle_16(result->value(1).toString());
                setRightAngle_16(result->value(2).toString());
                setMaterialHeight_16(result->value(3).toString());
                setMaterialLength_16(result->value(4).toString());
                setCutCount_16(result->value(5).toString());
            }
            else if(id == (downlimit + 16) )
            {
                setLeftAngle_17(result->value(1).toString());
                setRightAngle_17(result->value(2).toString());
                setMaterialHeight_17(result->value(3).toString());
                setMaterialLength_17(result->value(4).toString());
                setCutCount_17(result->value(5).toString());
            }
            else if(id == (downlimit + 17) )
            {
                setLeftAngle_18(result->value(1).toString());
                setRightAngle_18(result->value(2).toString());
                setMaterialHeight_18(result->value(3).toString());
                setMaterialLength_18(result->value(4).toString());
                setCutCount_18(result->value(5).toString());
            }
            else if(id == (downlimit + 18) )
            {
                setLeftAngle_19(result->value(1).toString());
                setRightAngle_19(result->value(2).toString());
                setMaterialHeight_19(result->value(3).toString());
                setMaterialLength_19(result->value(4).toString());
                setCutCount_19(result->value(5).toString());
            }
            else if(id == (downlimit + 19) )
            {
                setLeftAngle_20(result->value(1).toString());
                setRightAngle_20(result->value(2).toString());
                setMaterialHeight_20(result->value(3).toString());
                setMaterialLength_20(result->value(4).toString());
                setCutCount_20(result->value(5).toString());
            }
        }
    }
}

void Order_Process_Manager::addData()
{
    QString sql = "INSERT INTO Order_Process (LeftAngle , RightAngle , MaterialHeight , MaterialLength , CutCount) VALUES('','','','','')";

    qDebug()<<"Cpp:插入数据 sql:"<<sql;

    bool ok = Db->execSql(sql);
    if(!ok)
    {
        qDebug()<<"Cpp:添加数据失败";
    }
    else
    {
        qDebug()<<"Cpp:添加数据成功";
        getAllDataFromSQL();
    }
}

void Order_Process_Manager::saveData(int id, QString key, QString value)
{
    QString sql = "UPDATE Order_Process SET " + key + "='"+ value +"' WHERE ID = "+QString::number(id);

    qDebug()<<"Cpp:更新数据 sql:"<<sql;

    bool ok = Db->execSql(sql);

    if(!ok)
    {
        qDebug()<<"Cpp:更新数据失败";
    }
    else
    {
        qDebug()<<"Cpp:更新数据成功";
    }
}

void Order_Process_Manager::clearAllData(int packetNumber)
{
    qDebug()<<"触发 清空数据库 数据 函数";

    for(int i = 1 ; i <= 20 ; i++)
    {
        saveData(packetNumber*20 + i,"LeftAngle","45");
        saveData(packetNumber*20 + i,"RightAngle","45");
        saveData(packetNumber*20 + i,"MaterialHeight","0");
        saveData(packetNumber*20 + i,"MaterialLength","0");
        saveData(packetNumber*20 + i,"CutCount","0");
    }

    getDataByPacket(packetNumber);
}

Order_Process_Manager::Order_Process_Manager(QObject *parent)
    : QObject{parent}
{
    Db = Order_Process_Database::getInstance(parent);
}

Order_Process_Manager::~Order_Process_Manager()
{

}

QString Order_Process_Manager::LeftAngle_1() const
{
    return m_LeftAngle_1;
}

void Order_Process_Manager::setLeftAngle_1(const QString &newLeftAngle_1)
{
    if (m_LeftAngle_1 == newLeftAngle_1)
        return;
    m_LeftAngle_1 = newLeftAngle_1;
    emit LeftAngle_1Changed();
}

QString Order_Process_Manager::RightAngle_1() const
{
    return m_RightAngle_1;
}

void Order_Process_Manager::setRightAngle_1(const QString &newRightAngle_1)
{
    if (m_RightAngle_1 == newRightAngle_1)
        return;
    m_RightAngle_1 = newRightAngle_1;
    emit RightAngle_1Changed();
}

QString Order_Process_Manager::MaterialHeight_1() const
{
    return m_MaterialHeight_1;
}

void Order_Process_Manager::setMaterialHeight_1(const QString &newMaterialHeight_1)
{
    if (m_MaterialHeight_1 == newMaterialHeight_1)
        return;
    m_MaterialHeight_1 = newMaterialHeight_1;
    emit MaterialHeight_1Changed();
}

QString Order_Process_Manager::MaterialLength_1() const
{
    return m_MaterialLength_1;
}

void Order_Process_Manager::setMaterialLength_1(const QString &newMaterialLength_1)
{
    if (m_MaterialLength_1 == newMaterialLength_1)
        return;
    m_MaterialLength_1 = newMaterialLength_1;
    emit MaterialLength_1Changed();
}

QString Order_Process_Manager::CutCount_1() const
{
    return m_CutCount_1;
}

void Order_Process_Manager::setCutCount_1(const QString &newCutCount_1)
{
    if (m_CutCount_1 == newCutCount_1)
        return;
    m_CutCount_1 = newCutCount_1;
    emit CutCount_1Changed();
}

QString Order_Process_Manager::LeftAngle_2() const
{
    return m_LeftAngle_2;
}

void Order_Process_Manager::setLeftAngle_2(const QString &newLeftAngle_2)
{
    if (m_LeftAngle_2 == newLeftAngle_2)
        return;
    m_LeftAngle_2 = newLeftAngle_2;
    emit LeftAngle_2Changed();
}

QString Order_Process_Manager::RightAngle_2() const
{
    return m_RightAngle_2;
}

void Order_Process_Manager::setRightAngle_2(const QString &newRightAngle_2)
{
    if (m_RightAngle_2 == newRightAngle_2)
        return;
    m_RightAngle_2 = newRightAngle_2;
    emit RightAngle_2Changed();
}

QString Order_Process_Manager::MaterialHeight_2() const
{
    return m_MaterialHeight_2;
}

void Order_Process_Manager::setMaterialHeight_2(const QString &newMaterialHeight_2)
{
    if (m_MaterialHeight_2 == newMaterialHeight_2)
        return;
    m_MaterialHeight_2 = newMaterialHeight_2;
    emit MaterialHeight_2Changed();
}

QString Order_Process_Manager::MaterialLength_2() const
{
    return m_MaterialLength_2;
}

void Order_Process_Manager::setMaterialLength_2(const QString &newMaterialLength_2)
{
    if (m_MaterialLength_2 == newMaterialLength_2)
        return;
    m_MaterialLength_2 = newMaterialLength_2;
    emit MaterialLength_2Changed();
}

QString Order_Process_Manager::CutCount_2() const
{
    return m_CutCount_2;
}

void Order_Process_Manager::setCutCount_2(const QString &newCutCount_2)
{
    if (m_CutCount_2 == newCutCount_2)
        return;
    m_CutCount_2 = newCutCount_2;
    emit CutCount_2Changed();
}

QString Order_Process_Manager::LeftAngle_3() const
{
    return m_LeftAngle_3;
}

void Order_Process_Manager::setLeftAngle_3(const QString &newLeftAngle_3)
{
    if (m_LeftAngle_3 == newLeftAngle_3)
        return;
    m_LeftAngle_3 = newLeftAngle_3;
    emit LeftAngle_3Changed();
}

QString Order_Process_Manager::RightAngle_3() const
{
    return m_RightAngle_3;
}

void Order_Process_Manager::setRightAngle_3(const QString &newRightAngle_3)
{
    if (m_RightAngle_3 == newRightAngle_3)
        return;
    m_RightAngle_3 = newRightAngle_3;
    emit RightAngle_3Changed();
}

QString Order_Process_Manager::MaterialHeight_3() const
{
    return m_MaterialHeight_3;
}

void Order_Process_Manager::setMaterialHeight_3(const QString &newMaterialHeight_3)
{
    if (m_MaterialHeight_3 == newMaterialHeight_3)
        return;
    m_MaterialHeight_3 = newMaterialHeight_3;
    emit MaterialHeight_3Changed();
}

QString Order_Process_Manager::MaterialLength_3() const
{
    return m_MaterialLength_3;
}

void Order_Process_Manager::setMaterialLength_3(const QString &newMaterialLength_3)
{
    if (m_MaterialLength_3 == newMaterialLength_3)
        return;
    m_MaterialLength_3 = newMaterialLength_3;
    emit MaterialLength_3Changed();
}

QString Order_Process_Manager::CutCount_3() const
{
    return m_CutCount_3;
}

void Order_Process_Manager::setCutCount_3(const QString &newCutCount_3)
{
    if (m_CutCount_3 == newCutCount_3)
        return;
    m_CutCount_3 = newCutCount_3;
    emit CutCount_3Changed();
}

QString Order_Process_Manager::LeftAngle_4() const
{
    return m_LeftAngle_4;
}

void Order_Process_Manager::setLeftAngle_4(const QString &newLeftAngle_4)
{
    if (m_LeftAngle_4 == newLeftAngle_4)
        return;
    m_LeftAngle_4 = newLeftAngle_4;
    emit LeftAngle_4Changed();
}

QString Order_Process_Manager::RightAngle_4() const
{
    return m_RightAngle_4;
}

void Order_Process_Manager::setRightAngle_4(const QString &newRightAngle_4)
{
    if (m_RightAngle_4 == newRightAngle_4)
        return;
    m_RightAngle_4 = newRightAngle_4;
    emit RightAngle_4Changed();
}

QString Order_Process_Manager::MaterialHeight_4() const
{
    return m_MaterialHeight_4;
}

void Order_Process_Manager::setMaterialHeight_4(const QString &newMaterialHeight_4)
{
    if (m_MaterialHeight_4 == newMaterialHeight_4)
        return;
    m_MaterialHeight_4 = newMaterialHeight_4;
    emit MaterialHeight_4Changed();
}

QString Order_Process_Manager::MaterialLength_4() const
{
    return m_MaterialLength_4;
}

void Order_Process_Manager::setMaterialLength_4(const QString &newMaterialLength_4)
{
    if (m_MaterialLength_4 == newMaterialLength_4)
        return;
    m_MaterialLength_4 = newMaterialLength_4;
    emit MaterialLength_4Changed();
}

QString Order_Process_Manager::CutCount_4() const
{
    return m_CutCount_4;
}

void Order_Process_Manager::setCutCount_4(const QString &newCutCount_4)
{
    if (m_CutCount_4 == newCutCount_4)
        return;
    m_CutCount_4 = newCutCount_4;
    emit CutCount_4Changed();
}

QString Order_Process_Manager::LeftAngle_5() const
{
    return m_LeftAngle_5;
}

void Order_Process_Manager::setLeftAngle_5(const QString &newLeftAngle_5)
{
    if (m_LeftAngle_5 == newLeftAngle_5)
        return;
    m_LeftAngle_5 = newLeftAngle_5;
    emit LeftAngle_5Changed();
}

QString Order_Process_Manager::RightAngle_5() const
{
    return m_RightAngle_5;
}

void Order_Process_Manager::setRightAngle_5(const QString &newRightAngle_5)
{
    if (m_RightAngle_5 == newRightAngle_5)
        return;
    m_RightAngle_5 = newRightAngle_5;
    emit RightAngle_5Changed();
}

QString Order_Process_Manager::MaterialHeight_5() const
{
    return m_MaterialHeight_5;
}

void Order_Process_Manager::setMaterialHeight_5(const QString &newMaterialHeight_5)
{
    if (m_MaterialHeight_5 == newMaterialHeight_5)
        return;
    m_MaterialHeight_5 = newMaterialHeight_5;
    emit MaterialHeight_5Changed();
}

QString Order_Process_Manager::MaterialLength_5() const
{
    return m_MaterialLength_5;
}

void Order_Process_Manager::setMaterialLength_5(const QString &newMaterialLength_5)
{
    if (m_MaterialLength_5 == newMaterialLength_5)
        return;
    m_MaterialLength_5 = newMaterialLength_5;
    emit MaterialLength_5Changed();
}

QString Order_Process_Manager::CutCount_5() const
{
    return m_CutCount_5;
}

void Order_Process_Manager::setCutCount_5(const QString &newCutCount_5)
{
    if (m_CutCount_5 == newCutCount_5)
        return;
    m_CutCount_5 = newCutCount_5;
    emit CutCount_5Changed();
}

QString Order_Process_Manager::LeftAngle_6() const
{
    return m_LeftAngle_6;
}

void Order_Process_Manager::setLeftAngle_6(const QString &newLeftAngle_6)
{
    if (m_LeftAngle_6 == newLeftAngle_6)
        return;
    m_LeftAngle_6 = newLeftAngle_6;
    emit LeftAngle_6Changed();
}

QString Order_Process_Manager::RightAngle_6() const
{
    return m_RightAngle_6;
}

void Order_Process_Manager::setRightAngle_6(const QString &newRightAngle_6)
{
    if (m_RightAngle_6 == newRightAngle_6)
        return;
    m_RightAngle_6 = newRightAngle_6;
    emit RightAngle_6Changed();
}

QString Order_Process_Manager::MaterialHeight_6() const
{
    return m_MaterialHeight_6;
}

void Order_Process_Manager::setMaterialHeight_6(const QString &newMaterialHeight_6)
{
    if (m_MaterialHeight_6 == newMaterialHeight_6)
        return;
    m_MaterialHeight_6 = newMaterialHeight_6;
    emit MaterialHeight_6Changed();
}

QString Order_Process_Manager::MaterialLength_6() const
{
    return m_MaterialLength_6;
}

void Order_Process_Manager::setMaterialLength_6(const QString &newMaterialLength_6)
{
    if (m_MaterialLength_6 == newMaterialLength_6)
        return;
    m_MaterialLength_6 = newMaterialLength_6;
    emit MaterialLength_6Changed();
}

QString Order_Process_Manager::CutCount_6() const
{
    return m_CutCount_6;
}

void Order_Process_Manager::setCutCount_6(const QString &newCutCount_6)
{
    if (m_CutCount_6 == newCutCount_6)
        return;
    m_CutCount_6 = newCutCount_6;
    emit CutCount_6Changed();
}

QString Order_Process_Manager::LeftAngle_7() const
{
    return m_LeftAngle_7;
}

void Order_Process_Manager::setLeftAngle_7(const QString &newLeftAngle_7)
{
    if (m_LeftAngle_7 == newLeftAngle_7)
        return;
    m_LeftAngle_7 = newLeftAngle_7;
    emit LeftAngle_7Changed();
}

QString Order_Process_Manager::RightAngle_7() const
{
    return m_RightAngle_7;
}

void Order_Process_Manager::setRightAngle_7(const QString &newRightAngle_7)
{
    if (m_RightAngle_7 == newRightAngle_7)
        return;
    m_RightAngle_7 = newRightAngle_7;
    emit RightAngle_7Changed();
}

QString Order_Process_Manager::MaterialHeight_7() const
{
    return m_MaterialHeight_7;
}

void Order_Process_Manager::setMaterialHeight_7(const QString &newMaterialHeight_7)
{
    if (m_MaterialHeight_7 == newMaterialHeight_7)
        return;
    m_MaterialHeight_7 = newMaterialHeight_7;
    emit MaterialHeight_7Changed();
}

QString Order_Process_Manager::MaterialLength_7() const
{
    return m_MaterialLength_7;
}

void Order_Process_Manager::setMaterialLength_7(const QString &newMaterialLength_7)
{
    if (m_MaterialLength_7 == newMaterialLength_7)
        return;
    m_MaterialLength_7 = newMaterialLength_7;
    emit MaterialLength_7Changed();
}

QString Order_Process_Manager::CutCount_7() const
{
    return m_CutCount_7;
}

void Order_Process_Manager::setCutCount_7(const QString &newCutCount_7)
{
    if (m_CutCount_7 == newCutCount_7)
        return;
    m_CutCount_7 = newCutCount_7;
    emit CutCount_7Changed();
}

QString Order_Process_Manager::LeftAngle_8() const
{
    return m_LeftAngle_8;
}

void Order_Process_Manager::setLeftAngle_8(const QString &newLeftAngle_8)
{
    if (m_LeftAngle_8 == newLeftAngle_8)
        return;
    m_LeftAngle_8 = newLeftAngle_8;
    emit LeftAngle_8Changed();
}

QString Order_Process_Manager::RightAngle_8() const
{
    return m_RightAngle_8;
}

void Order_Process_Manager::setRightAngle_8(const QString &newRightAngle_8)
{
    if (m_RightAngle_8 == newRightAngle_8)
        return;
    m_RightAngle_8 = newRightAngle_8;
    emit RightAngle_8Changed();
}

QString Order_Process_Manager::MaterialHeight_8() const
{
    return m_MaterialHeight_8;
}

void Order_Process_Manager::setMaterialHeight_8(const QString &newMaterialHeight_8)
{
    if (m_MaterialHeight_8 == newMaterialHeight_8)
        return;
    m_MaterialHeight_8 = newMaterialHeight_8;
    emit MaterialHeight_8Changed();
}

QString Order_Process_Manager::MaterialLength_8() const
{
    return m_MaterialLength_8;
}

void Order_Process_Manager::setMaterialLength_8(const QString &newMaterialLength_8)
{
    if (m_MaterialLength_8 == newMaterialLength_8)
        return;
    m_MaterialLength_8 = newMaterialLength_8;
    emit MaterialLength_8Changed();
}

QString Order_Process_Manager::CutCount_8() const
{
    return m_CutCount_8;
}

void Order_Process_Manager::setCutCount_8(const QString &newCutCount_8)
{
    if (m_CutCount_8 == newCutCount_8)
        return;
    m_CutCount_8 = newCutCount_8;
    emit CutCount_8Changed();
}

QString Order_Process_Manager::LeftAngle_9() const
{
    return m_LeftAngle_9;
}

void Order_Process_Manager::setLeftAngle_9(const QString &newLeftAngle_9)
{
    if (m_LeftAngle_9 == newLeftAngle_9)
        return;
    m_LeftAngle_9 = newLeftAngle_9;
    emit LeftAngle_9Changed();
}

QString Order_Process_Manager::RightAngle_9() const
{
    return m_RightAngle_9;
}

void Order_Process_Manager::setRightAngle_9(const QString &newRightAngle_9)
{
    if (m_RightAngle_9 == newRightAngle_9)
        return;
    m_RightAngle_9 = newRightAngle_9;
    emit RightAngle_9Changed();
}

QString Order_Process_Manager::MaterialHeight_9() const
{
    return m_MaterialHeight_9;
}

void Order_Process_Manager::setMaterialHeight_9(const QString &newMaterialHeight_9)
{
    if (m_MaterialHeight_9 == newMaterialHeight_9)
        return;
    m_MaterialHeight_9 = newMaterialHeight_9;
    emit MaterialHeight_9Changed();
}

QString Order_Process_Manager::MaterialLength_9() const
{
    return m_MaterialLength_9;
}

void Order_Process_Manager::setMaterialLength_9(const QString &newMaterialLength_9)
{
    if (m_MaterialLength_9 == newMaterialLength_9)
        return;
    m_MaterialLength_9 = newMaterialLength_9;
    emit MaterialLength_9Changed();
}

QString Order_Process_Manager::CutCount_9() const
{
    return m_CutCount_9;
}

void Order_Process_Manager::setCutCount_9(const QString &newCutCount_9)
{
    if (m_CutCount_9 == newCutCount_9)
        return;
    m_CutCount_9 = newCutCount_9;
    emit CutCount_9Changed();
}

QString Order_Process_Manager::LeftAngle_10() const
{
    return m_LeftAngle_10;
}

void Order_Process_Manager::setLeftAngle_10(const QString &newLeftAngle_10)
{
    if (m_LeftAngle_10 == newLeftAngle_10)
        return;
    m_LeftAngle_10 = newLeftAngle_10;
    emit LeftAngle_10Changed();
}

QString Order_Process_Manager::RightAngle_10() const
{
    return m_RightAngle_10;
}

void Order_Process_Manager::setRightAngle_10(const QString &newRightAngle_10)
{
    if (m_RightAngle_10 == newRightAngle_10)
        return;
    m_RightAngle_10 = newRightAngle_10;
    emit RightAngle_10Changed();
}

QString Order_Process_Manager::MaterialHeight_10() const
{
    return m_MaterialHeight_10;
}

void Order_Process_Manager::setMaterialHeight_10(const QString &newMaterialHeight_10)
{
    if (m_MaterialHeight_10 == newMaterialHeight_10)
        return;
    m_MaterialHeight_10 = newMaterialHeight_10;
    emit MaterialHeight_10Changed();
}

QString Order_Process_Manager::MaterialLength_10() const
{
    return m_MaterialLength_10;
}

void Order_Process_Manager::setMaterialLength_10(const QString &newMaterialLength_10)
{
    if (m_MaterialLength_10 == newMaterialLength_10)
        return;
    m_MaterialLength_10 = newMaterialLength_10;
    emit MaterialLength_10Changed();
}

QString Order_Process_Manager::CutCount_10() const
{
    return m_CutCount_10;
}

void Order_Process_Manager::setCutCount_10(const QString &newCutCount_10)
{
    if (m_CutCount_10 == newCutCount_10)
        return;
    m_CutCount_10 = newCutCount_10;
    emit CutCount_10Changed();
}

QString Order_Process_Manager::LeftAngle_11() const
{
    return m_LeftAngle_11;
}

void Order_Process_Manager::setLeftAngle_11(const QString &newLeftAngle_11)
{
    if (m_LeftAngle_11 == newLeftAngle_11)
        return;
    m_LeftAngle_11 = newLeftAngle_11;
    emit LeftAngle_11Changed();
}

QString Order_Process_Manager::RightAngle_11() const
{
    return m_RightAngle_11;
}

void Order_Process_Manager::setRightAngle_11(const QString &newRightAngle_11)
{
    if (m_RightAngle_11 == newRightAngle_11)
        return;
    m_RightAngle_11 = newRightAngle_11;
    emit RightAngle_11Changed();
}

QString Order_Process_Manager::MaterialHeight_11() const
{
    return m_MaterialHeight_11;
}

void Order_Process_Manager::setMaterialHeight_11(const QString &newMaterialHeight_11)
{
    if (m_MaterialHeight_11 == newMaterialHeight_11)
        return;
    m_MaterialHeight_11 = newMaterialHeight_11;
    emit MaterialHeight_11Changed();
}

QString Order_Process_Manager::MaterialLength_11() const
{
    return m_MaterialLength_11;
}

void Order_Process_Manager::setMaterialLength_11(const QString &newMaterialLength_11)
{
    if (m_MaterialLength_11 == newMaterialLength_11)
        return;
    m_MaterialLength_11 = newMaterialLength_11;
    emit MaterialLength_11Changed();
}

QString Order_Process_Manager::CutCount_11() const
{
    return m_CutCount_11;
}

void Order_Process_Manager::setCutCount_11(const QString &newCutCount_11)
{
    if (m_CutCount_11 == newCutCount_11)
        return;
    m_CutCount_11 = newCutCount_11;
    emit CutCount_11Changed();
}

QString Order_Process_Manager::LeftAngle_12() const
{
    return m_LeftAngle_12;
}

void Order_Process_Manager::setLeftAngle_12(const QString &newLeftAngle_12)
{
    if (m_LeftAngle_12 == newLeftAngle_12)
        return;
    m_LeftAngle_12 = newLeftAngle_12;
    emit LeftAngle_12Changed();
}

QString Order_Process_Manager::RightAngle_12() const
{
    return m_RightAngle_12;
}

void Order_Process_Manager::setRightAngle_12(const QString &newRightAngle_12)
{
    if (m_RightAngle_12 == newRightAngle_12)
        return;
    m_RightAngle_12 = newRightAngle_12;
    emit RightAngle_12Changed();
}

QString Order_Process_Manager::MaterialHeight_12() const
{
    return m_MaterialHeight_12;
}

void Order_Process_Manager::setMaterialHeight_12(const QString &newMaterialHeight_12)
{
    if (m_MaterialHeight_12 == newMaterialHeight_12)
        return;
    m_MaterialHeight_12 = newMaterialHeight_12;
    emit MaterialHeight_12Changed();
}

QString Order_Process_Manager::MaterialLength_12() const
{
    return m_MaterialLength_12;
}

void Order_Process_Manager::setMaterialLength_12(const QString &newMaterialLength_12)
{
    if (m_MaterialLength_12 == newMaterialLength_12)
        return;
    m_MaterialLength_12 = newMaterialLength_12;
    emit MaterialLength_12Changed();
}

QString Order_Process_Manager::CutCount_12() const
{
    return m_CutCount_12;
}

void Order_Process_Manager::setCutCount_12(const QString &newCutCount_12)
{
    if (m_CutCount_12 == newCutCount_12)
        return;
    m_CutCount_12 = newCutCount_12;
    emit CutCount_12Changed();
}

QString Order_Process_Manager::LeftAngle_13() const
{
    return m_LeftAngle_13;
}

void Order_Process_Manager::setLeftAngle_13(const QString &newLeftAngle_13)
{
    if (m_LeftAngle_13 == newLeftAngle_13)
        return;
    m_LeftAngle_13 = newLeftAngle_13;
    emit LeftAngle_13Changed();
}

QString Order_Process_Manager::RightAngle_13() const
{
    return m_RightAngle_13;
}

void Order_Process_Manager::setRightAngle_13(const QString &newRightAngle_13)
{
    if (m_RightAngle_13 == newRightAngle_13)
        return;
    m_RightAngle_13 = newRightAngle_13;
    emit RightAngle_13Changed();
}

QString Order_Process_Manager::MaterialHeight_13() const
{
    return m_MaterialHeight_13;
}

void Order_Process_Manager::setMaterialHeight_13(const QString &newMaterialHeight_13)
{
    if (m_MaterialHeight_13 == newMaterialHeight_13)
        return;
    m_MaterialHeight_13 = newMaterialHeight_13;
    emit MaterialHeight_13Changed();
}

QString Order_Process_Manager::MaterialLength_13() const
{
    return m_MaterialLength_13;
}

void Order_Process_Manager::setMaterialLength_13(const QString &newMaterialLength_13)
{
    if (m_MaterialLength_13 == newMaterialLength_13)
        return;
    m_MaterialLength_13 = newMaterialLength_13;
    emit MaterialLength_13Changed();
}

QString Order_Process_Manager::CutCount_13() const
{
    return m_CutCount_13;
}

void Order_Process_Manager::setCutCount_13(const QString &newCutCount_13)
{
    if (m_CutCount_13 == newCutCount_13)
        return;
    m_CutCount_13 = newCutCount_13;
    emit CutCount_13Changed();
}

QString Order_Process_Manager::LeftAngle_14() const
{
    return m_LeftAngle_14;
}

void Order_Process_Manager::setLeftAngle_14(const QString &newLeftAngle_14)
{
    if (m_LeftAngle_14 == newLeftAngle_14)
        return;
    m_LeftAngle_14 = newLeftAngle_14;
    emit LeftAngle_14Changed();
}

QString Order_Process_Manager::RightAngle_14() const
{
    return m_RightAngle_14;
}

void Order_Process_Manager::setRightAngle_14(const QString &newRightAngle_14)
{
    if (m_RightAngle_14 == newRightAngle_14)
        return;
    m_RightAngle_14 = newRightAngle_14;
    emit RightAngle_14Changed();
}

QString Order_Process_Manager::MaterialHeight_14() const
{
    return m_MaterialHeight_14;
}

void Order_Process_Manager::setMaterialHeight_14(const QString &newMaterialHeight_14)
{
    if (m_MaterialHeight_14 == newMaterialHeight_14)
        return;
    m_MaterialHeight_14 = newMaterialHeight_14;
    emit MaterialHeight_14Changed();
}

QString Order_Process_Manager::MaterialLength_14() const
{
    return m_MaterialLength_14;
}

void Order_Process_Manager::setMaterialLength_14(const QString &newMaterialLength_14)
{
    if (m_MaterialLength_14 == newMaterialLength_14)
        return;
    m_MaterialLength_14 = newMaterialLength_14;
    emit MaterialLength_14Changed();
}

QString Order_Process_Manager::CutCount_14() const
{
    return m_CutCount_14;
}

void Order_Process_Manager::setCutCount_14(const QString &newCutCount_14)
{
    if (m_CutCount_14 == newCutCount_14)
        return;
    m_CutCount_14 = newCutCount_14;
    emit CutCount_14Changed();
}

QString Order_Process_Manager::LeftAngle_15() const
{
    return m_LeftAngle_15;
}

void Order_Process_Manager::setLeftAngle_15(const QString &newLeftAngle_15)
{
    if (m_LeftAngle_15 == newLeftAngle_15)
        return;
    m_LeftAngle_15 = newLeftAngle_15;
    emit LeftAngle_15Changed();
}

QString Order_Process_Manager::RightAngle_15() const
{
    return m_RightAngle_15;
}

void Order_Process_Manager::setRightAngle_15(const QString &newRightAngle_15)
{
    if (m_RightAngle_15 == newRightAngle_15)
        return;
    m_RightAngle_15 = newRightAngle_15;
    emit RightAngle_15Changed();
}

QString Order_Process_Manager::MaterialHeight_15() const
{
    return m_MaterialHeight_15;
}

void Order_Process_Manager::setMaterialHeight_15(const QString &newMaterialHeight_15)
{
    if (m_MaterialHeight_15 == newMaterialHeight_15)
        return;
    m_MaterialHeight_15 = newMaterialHeight_15;
    emit MaterialHeight_15Changed();
}

QString Order_Process_Manager::MaterialLength_15() const
{
    return m_MaterialLength_15;
}

void Order_Process_Manager::setMaterialLength_15(const QString &newMaterialLength_15)
{
    if (m_MaterialLength_15 == newMaterialLength_15)
        return;
    m_MaterialLength_15 = newMaterialLength_15;
    emit MaterialLength_15Changed();
}

QString Order_Process_Manager::CutCount_15() const
{
    return m_CutCount_15;
}

void Order_Process_Manager::setCutCount_15(const QString &newCutCount_15)
{
    if (m_CutCount_15 == newCutCount_15)
        return;
    m_CutCount_15 = newCutCount_15;
    emit CutCount_15Changed();
}

QString Order_Process_Manager::LeftAngle_16() const
{
    return m_LeftAngle_16;
}

void Order_Process_Manager::setLeftAngle_16(const QString &newLeftAngle_16)
{
    if (m_LeftAngle_16 == newLeftAngle_16)
        return;
    m_LeftAngle_16 = newLeftAngle_16;
    emit LeftAngle_16Changed();
}

QString Order_Process_Manager::RightAngle_16() const
{
    return m_RightAngle_16;
}

void Order_Process_Manager::setRightAngle_16(const QString &newRightAngle_16)
{
    if (m_RightAngle_16 == newRightAngle_16)
        return;
    m_RightAngle_16 = newRightAngle_16;
    emit RightAngle_16Changed();
}

QString Order_Process_Manager::MaterialHeight_16() const
{
    return m_MaterialHeight_16;
}

void Order_Process_Manager::setMaterialHeight_16(const QString &newMaterialHeight_16)
{
    if (m_MaterialHeight_16 == newMaterialHeight_16)
        return;
    m_MaterialHeight_16 = newMaterialHeight_16;
    emit MaterialHeight_16Changed();
}

QString Order_Process_Manager::MaterialLength_16() const
{
    return m_MaterialLength_16;
}

void Order_Process_Manager::setMaterialLength_16(const QString &newMaterialLength_16)
{
    if (m_MaterialLength_16 == newMaterialLength_16)
        return;
    m_MaterialLength_16 = newMaterialLength_16;
    emit MaterialLength_16Changed();
}

QString Order_Process_Manager::CutCount_16() const
{
    return m_CutCount_16;
}

void Order_Process_Manager::setCutCount_16(const QString &newCutCount_16)
{
    if (m_CutCount_16 == newCutCount_16)
        return;
    m_CutCount_16 = newCutCount_16;
    emit CutCount_16Changed();
}

QString Order_Process_Manager::LeftAngle_17() const
{
    return m_LeftAngle_17;
}

void Order_Process_Manager::setLeftAngle_17(const QString &newLeftAngle_17)
{
    if (m_LeftAngle_17 == newLeftAngle_17)
        return;
    m_LeftAngle_17 = newLeftAngle_17;
    emit LeftAngle_17Changed();
}

QString Order_Process_Manager::RightAngle_17() const
{
    return m_RightAngle_17;
}

void Order_Process_Manager::setRightAngle_17(const QString &newRightAngle_17)
{
    if (m_RightAngle_17 == newRightAngle_17)
        return;
    m_RightAngle_17 = newRightAngle_17;
    emit RightAngle_17Changed();
}

QString Order_Process_Manager::MaterialHeight_17() const
{
    return m_MaterialHeight_17;
}

void Order_Process_Manager::setMaterialHeight_17(const QString &newMaterialHeight_17)
{
    if (m_MaterialHeight_17 == newMaterialHeight_17)
        return;
    m_MaterialHeight_17 = newMaterialHeight_17;
    emit MaterialHeight_17Changed();
}

QString Order_Process_Manager::MaterialLength_17() const
{
    return m_MaterialLength_17;
}

void Order_Process_Manager::setMaterialLength_17(const QString &newMaterialLength_17)
{
    if (m_MaterialLength_17 == newMaterialLength_17)
        return;
    m_MaterialLength_17 = newMaterialLength_17;
    emit MaterialLength_17Changed();
}

QString Order_Process_Manager::CutCount_17() const
{
    return m_CutCount_17;
}

void Order_Process_Manager::setCutCount_17(const QString &newCutCount_17)
{
    if (m_CutCount_17 == newCutCount_17)
        return;
    m_CutCount_17 = newCutCount_17;
    emit CutCount_17Changed();
}

QString Order_Process_Manager::LeftAngle_18() const
{
    return m_LeftAngle_18;
}

void Order_Process_Manager::setLeftAngle_18(const QString &newLeftAngle_18)
{
    if (m_LeftAngle_18 == newLeftAngle_18)
        return;
    m_LeftAngle_18 = newLeftAngle_18;
    emit LeftAngle_18Changed();
}

QString Order_Process_Manager::RightAngle_18() const
{
    return m_RightAngle_18;
}

void Order_Process_Manager::setRightAngle_18(const QString &newRightAngle_18)
{
    if (m_RightAngle_18 == newRightAngle_18)
        return;
    m_RightAngle_18 = newRightAngle_18;
    emit RightAngle_18Changed();
}

QString Order_Process_Manager::MaterialHeight_18() const
{
    return m_MaterialHeight_18;
}

void Order_Process_Manager::setMaterialHeight_18(const QString &newMaterialHeight_18)
{
    if (m_MaterialHeight_18 == newMaterialHeight_18)
        return;
    m_MaterialHeight_18 = newMaterialHeight_18;
    emit MaterialHeight_18Changed();
}

QString Order_Process_Manager::MaterialLength_18() const
{
    return m_MaterialLength_18;
}

void Order_Process_Manager::setMaterialLength_18(const QString &newMaterialLength_18)
{
    if (m_MaterialLength_18 == newMaterialLength_18)
        return;
    m_MaterialLength_18 = newMaterialLength_18;
    emit MaterialLength_18Changed();
}

QString Order_Process_Manager::CutCount_18() const
{
    return m_CutCount_18;
}

void Order_Process_Manager::setCutCount_18(const QString &newCutCount_18)
{
    if (m_CutCount_18 == newCutCount_18)
        return;
    m_CutCount_18 = newCutCount_18;
    emit CutCount_18Changed();
}

QString Order_Process_Manager::LeftAngle_19() const
{
    return m_LeftAngle_19;
}

void Order_Process_Manager::setLeftAngle_19(const QString &newLeftAngle_19)
{
    if (m_LeftAngle_19 == newLeftAngle_19)
        return;
    m_LeftAngle_19 = newLeftAngle_19;
    emit LeftAngle_19Changed();
}

QString Order_Process_Manager::RightAngle_19() const
{
    return m_RightAngle_19;
}

void Order_Process_Manager::setRightAngle_19(const QString &newRightAngle_19)
{
    if (m_RightAngle_19 == newRightAngle_19)
        return;
    m_RightAngle_19 = newRightAngle_19;
    emit RightAngle_19Changed();
}

QString Order_Process_Manager::MaterialHeight_19() const
{
    return m_MaterialHeight_19;
}

void Order_Process_Manager::setMaterialHeight_19(const QString &newMaterialHeight_19)
{
    if (m_MaterialHeight_19 == newMaterialHeight_19)
        return;
    m_MaterialHeight_19 = newMaterialHeight_19;
    emit MaterialHeight_19Changed();
}

QString Order_Process_Manager::MaterialLength_19() const
{
    return m_MaterialLength_19;
}

void Order_Process_Manager::setMaterialLength_19(const QString &newMaterialLength_19)
{
    if (m_MaterialLength_19 == newMaterialLength_19)
        return;
    m_MaterialLength_19 = newMaterialLength_19;
    emit MaterialLength_19Changed();
}

QString Order_Process_Manager::CutCount_19() const
{
    return m_CutCount_19;
}

void Order_Process_Manager::setCutCount_19(const QString &newCutCount_19)
{
    if (m_CutCount_19 == newCutCount_19)
        return;
    m_CutCount_19 = newCutCount_19;
    emit CutCount_19Changed();
}

QString Order_Process_Manager::LeftAngle_20() const
{
    return m_LeftAngle_20;
}

void Order_Process_Manager::setLeftAngle_20(const QString &newLeftAngle_20)
{
    if (m_LeftAngle_20 == newLeftAngle_20)
        return;
    m_LeftAngle_20 = newLeftAngle_20;
    emit LeftAngle_20Changed();
}

QString Order_Process_Manager::RightAngle_20() const
{
    return m_RightAngle_20;
}

void Order_Process_Manager::setRightAngle_20(const QString &newRightAngle_20)
{
    if (m_RightAngle_20 == newRightAngle_20)
        return;
    m_RightAngle_20 = newRightAngle_20;
    emit RightAngle_20Changed();
}

QString Order_Process_Manager::MaterialHeight_20() const
{
    return m_MaterialHeight_20;
}

void Order_Process_Manager::setMaterialHeight_20(const QString &newMaterialHeight_20)
{
    if (m_MaterialHeight_20 == newMaterialHeight_20)
        return;
    m_MaterialHeight_20 = newMaterialHeight_20;
    emit MaterialHeight_20Changed();
}

QString Order_Process_Manager::MaterialLength_20() const
{
    return m_MaterialLength_20;
}

void Order_Process_Manager::setMaterialLength_20(const QString &newMaterialLength_20)
{
    if (m_MaterialLength_20 == newMaterialLength_20)
        return;
    m_MaterialLength_20 = newMaterialLength_20;
    emit MaterialLength_20Changed();
}

QString Order_Process_Manager::CutCount_20() const
{
    return m_CutCount_20;
}

void Order_Process_Manager::setCutCount_20(const QString &newCutCount_20)
{
    if (m_CutCount_20 == newCutCount_20)
        return;
    m_CutCount_20 = newCutCount_20;
    emit CutCount_20Changed();
}

int Order_Process_Manager::packetNumber() const
{
    return m_packetNumber;
}

void Order_Process_Manager::setPacketNumber(int newPacketNumber)
{
    if (m_packetNumber == newPacketNumber)
        return;
    m_packetNumber = newPacketNumber;
    emit packetNumberChanged();
}
